home *** CD-ROM | disk | FTP | other *** search
/ AOL File Library: 2,801 to 2,900 / aol-file-protocol-4400-2801-to-2900.zip / AOLDLs / C++ Files Library / SK (Sockects) 1.4.1 r2 / SK v1.4.1 r2.sit / SK 1.4.1 r2 / SK / SK Sources / SK_NetDB.cc < prev    next >
Text File  |  1994-06-16  |  20KB  |  826 lines
  1. /***************************************************************************
  2. * 
  3. * 
  4. * Copyright ⌐ 1992-1994 Matthias Neeracher and the Decision Systems Group
  5. * 
  6. * Permission is granted to anyone to use this software for any purpose on
  7. * any computer system, and to redistribute it freely, subject to the
  8. * following restrictions:
  9. * 
  10. * 1) The authors and the Decision Systems Group are not responsible for 
  11. *    the direct or indirect consequences of use of this software, no matter 
  12. *    how awful, even if they arise from defects in the software itself.
  13. *    This restriction applies to the use of this and any derived source code 
  14. *    and also to the use of all binary produced from this and any derived 
  15. *    source code.
  16. * 2) The origin and copyrights of this software must not be misrepresented, 
  17. *    either by explicit claim or by omission or alteration of copyright or
  18. *    authorship header information in this file or in any derived file.
  19. * 3) Altered or derived versions must be plainly marked as such, and must not
  20. *    be misrepresented as being the original software.
  21. * 
  22. * We encourage users of this software to provide feedback, bug fixes,
  23. * and enhancements to the authors for incorporation into future releases.
  24. *
  25. * ==========================================================================
  26. * 
  27. * FILE: SK_NetDB.cc
  28. * 
  29. * AUTHOR: Matthias Neeracher and Stephan Deibel
  30. * 
  31. * CREATION DATE: 12Sep92
  32. * 
  33. * VERSION: 13Jun94
  34. * 
  35. * DESCRIPTION: 
  36. *
  37. * Conversion routines for internet names and addresses
  38. * 
  39. * Gethostbyname() and gethostbyaddr() each return a pointer to an
  40. * object with the following structure describing an Internet
  41. * host referenced by name or by address, respectively. This
  42. * structure contains the information obtained from the MacTCP
  43. * name server.
  44. *
  45. * struct hostent
  46. * {
  47. *      char * h_name;
  48. *      char ** h_aliases;
  49. *      int  h_addrtype;
  50. *      int  h_length;
  51. *      char ** h_addr_list;
  52. * };
  53. * #define h_addr h_addr_list[0]
  54. *
  55. * The members of this structure are:
  56. *
  57. * h_name       Official name of the host.
  58. *
  59. * h_aliases    A zero terminated array of alternate names for the host.
  60. *
  61. * h_addrtype   The type of address being returned; always AF_INET.
  62. *
  63. * h_length     The length,in bytes, of the address.
  64. *
  65. * h_addr_list  A zero terminated array of network addresses for the host.
  66. *
  67. * Error return status from () and gethostbyaddr() is
  68. * indicated by return of a null pointer.  The external integer
  69. * h_errno may then be  checked  to  see  whether  this  is  a
  70. * temporary  failure  or  an  invalid  or  unknown  host.  The
  71. * routine herror  can  be  used  to  print  an error  message
  72. * describing the failure.  If its argument string is non-NULL,
  73. * it is printed, followed by a colon and a space.   The  error
  74. * message is printed with a trailing newline.
  75. *
  76. * h_errno can have the following values:
  77. *
  78. *   HOST_NOT_FOUND  No such host is known.
  79. *
  80. *   TRY_AGAIN        This is usually a temporary error and
  81. *                    means   that  the  local  server  did  not
  82. *                    receive a response from  an  authoritative
  83. *                    server.   A  retry at some later time may
  84. *                    succeed.
  85. *
  86. *   NO_RECOVERY        Some unexpected server failure was encountered.
  87. *                     This is a non-recoverable error.
  88. *
  89. *   NO_DATA            The requested name is valid but  does  not
  90. *                    have   an IP  address;  this  is not  a
  91. *                    temporary error. This means that the  name
  92. *                    is known  to the name server but there is
  93. *                    no address  associated  with  this  name.
  94. *                    Another type of request to the name server
  95. *                    using this domain name will result in  an
  96. *                    answer;  for example, a mail-forwarder may
  97. *                    be registered for this domain.
  98. *                    (NOT GENERATED BY THIS IMPLEMENTATION)
  99. * NOTES: 
  100. * 
  101. * 0) This code was derived from Matthias Neerarcher's GUSI 1.1.0 and
  102. *    the socket library written by Charlie Reiman (creiman@ncsa.uiuc.edu)
  103. *    and Tom Milligan (milligan@madhaus.utcs.utoronto.ca); Copyrights
  104. *    are subject to this origin.
  105. *
  106. * TO DO:
  107. *
  108. * 0) Remove use of globals for building return values?
  109. *
  110. * MODIFICATIONS: 
  111. * --------------------------------------------------------------------------
  112. * Date     Name      Description of modification
  113. * --------------------------------------------------------------------------
  114. * 
  115. * 14Sep92    MN       Maybe it works, maybe it doesn't
  116. * 21Nov92    MN       Remove force_active
  117. * 19Jan93    MN       Can't set aliases to NULL.
  118. * 13Jul93    SD       Port to THINK C++ 6.0
  119. * 21Jul93    SD       Subsetted to only TCP/UDP, applied DSG naming 
  120. *                    conventions and commenting guidelines, and
  121. *                    changed name to "SK" for clear distinction from
  122. *                    the GUSI code from which this was derived
  123. * 13Jun94   SD       Updated based on relevant changes to GUSI (through 1.4.1)
  124. * 
  125. */
  126.  
  127. #include "SK_INET_P.hh"
  128.  
  129. #include "Folders.h"
  130. #include "SK_Utilities_P.h"
  131.  
  132.  
  133. /**************************************************************************/ 
  134. /**************************************************************************/ 
  135. /* CONSTANTS */
  136.  
  137. #define MAXALIASES 0
  138.  
  139.  
  140. /**************************************************************************/ 
  141. /**************************************************************************/ 
  142. /* GLOBALS */
  143.  
  144. /* The global error value used by () and gethostbyaddr() */
  145. /* (declared in <netdb.h>) */
  146. int h_errno;
  147.  
  148. /* Global Macintosh hostInfo for DNS query returns */
  149. static struct hostInfo SKg_MacHost;
  150.  
  151. /* Global alias pointers for DNS query returns */
  152. static char *SKg_AliasPtrs[MAXALIASES+1] = {NULL};
  153.  
  154. /* Global address pointers for DNS query returns */
  155. static ip_addr *SKg_AddrPtrs[NUM_ALT_ADDRS+1];
  156.  
  157. /* Global used to collect other (Mac-specific) globals into a Unix hostent structure */
  158. static struct hostent SKg_UnixHost =
  159. {
  160.     SKg_MacHost.cname,
  161.     SKg_AliasPtrs,
  162.     AF_INET,
  163.     sizeof(ip_addr),
  164.     (char **) SKg_AddrPtrs
  165. };
  166.  
  167.  
  168. /**************************************************************************/ 
  169. /**************************************************************************/ 
  170. /* FUNCTIONS */
  171.  
  172.  
  173. /****************************************************************************
  174. * FUNCTION:
  175. *
  176. * DNRDone
  177. *
  178. * DESCRIPTION:
  179. *
  180. * Callback function used to change state when done waiting for DNR
  181. *
  182. * PARAMETERS:
  183. *
  184. * struct hostInfo *            -- The MacTCP hostInfo structure with DNR result
  185. * Boolean *                    -- Pointer to boolean indicating that DNR is done
  186. *
  187. */
  188.  
  189. pascal void DNRDone(struct hostInfo *, Boolean * done)
  190. {
  191.     *done = true;
  192. }
  193.  
  194.  
  195. /*************************************************************************** *
  196. * FUNCTION:
  197. *
  198. * make_in_addr
  199. *
  200. * DESCRIPTION:
  201. *
  202. * Make an in_addr out of a given ip_addr
  203. *
  204. * PARAMETERS:
  205. *
  206. * ip_addr        -- The given ip_addr
  207. *
  208. * RETURNS:
  209. *
  210. * in_addr        -- The resulting in_addr
  211. *
  212. */
  213.  
  214. inline struct in_addr make_in_addr(ip_addr addr)
  215. {
  216.     struct in_addr    res;
  217.  
  218.     res.s_addr    =    addr;
  219.  
  220.     return res;
  221. }
  222.  
  223.  
  224. /*************************************************************************** *
  225. * FUNCTION:
  226. *
  227. * gethostbyname
  228. *
  229. * DESCRIPTION:
  230. *
  231. * Find the ip address(es) and list of aliases of an internet host using 
  232. * one of its internet names.
  233. *
  234. * PARAMETERS:
  235. *
  236. * char *            -- The internet name in standard dotted internet name format
  237. *                       (e.g., dsg.harvard.edu)
  238. *
  239. * RETURNS:
  240. *
  241. * struct hostent *    -- The hostent structure containing the result of the query
  242. *                       (or NULL on error)
  243. *
  244. */
  245.  
  246. struct hostent * gethostbyname(char *name)
  247. {
  248.     Boolean done;
  249.     int i;
  250.  
  251.     if (SKg_INETSockets.Resolver()) {
  252.         h_errno = NO_RECOVERY;    
  253.         return NULL;
  254.     }
  255.     
  256.     for (i=0; i<NUM_ALT_ADDRS; i++)
  257.         SKg_MacHost.addr[i] = 0;
  258.  
  259.     done = false;
  260.  
  261.     if (StrToAddr(name, &SKg_MacHost, ResultProcPtr(DNRDone), (char *) &done) == cacheFault)
  262.         SPINP(!done,SKk_NAME,0L);
  263.  
  264.     switch (SKg_MacHost.rtnCode) {
  265.         case noErr: break;
  266.  
  267.         case nameSyntaxErr:        h_errno = HOST_NOT_FOUND;    return(NULL);
  268.         case cacheFault:        h_errno = NO_RECOVERY;        return(NULL);
  269.         case noResultProc:        h_errno = NO_RECOVERY;        return(NULL);
  270.         case noNameServer:        h_errno = HOST_NOT_FOUND;    return(NULL);
  271.         case authNameErr:        h_errno = HOST_NOT_FOUND;    return(NULL);
  272.         case noAnsErr:            h_errno = TRY_AGAIN;        return(NULL);
  273.         case dnrErr:            h_errno = NO_RECOVERY;        return(NULL);
  274.         case outOfMemory:        h_errno = TRY_AGAIN;        return(NULL);
  275.         default:                h_errno = NO_RECOVERY;        return(NULL);
  276.     }
  277.  
  278.     /* was the 'name' an IP address? */
  279.     if (SKg_MacHost.cname[0] == 0) {
  280.         h_errno = HOST_NOT_FOUND;
  281.         return(NULL);
  282.     }
  283.  
  284.     /* for some reason there is a dot at the end of the name */
  285.     i = strlen(SKg_MacHost.cname) - 1;
  286.     if (SKg_MacHost.cname[i] == '.')
  287.         SKg_MacHost.cname[i] = 0;
  288.  
  289.     for (i=0; i<NUM_ALT_ADDRS && SKg_MacHost.addr[i]!=0; i++)
  290.         SKg_AddrPtrs[i] =    (ip_addr *) &SKg_MacHost.addr[i];
  291.  
  292.     SKg_AddrPtrs[i] = NULL;
  293.  
  294.     return &SKg_UnixHost;
  295. }
  296.  
  297.  
  298. /*************************************************************************** *
  299. * FUNCTION:
  300. *
  301. * gethostbyaddr
  302. *
  303. * DESCRIPTION:
  304. *
  305. * Find the ip address(es) and list of aliases of an internet host using 
  306. * the host's internet number.
  307. *
  308. * PARAMETERS:
  309. *
  310. * struct in_addr *        -- The internet address of the host
  311. * int                    -- unused
  312. * int                    -- unused
  313. *
  314. * RETURNS:
  315. *
  316. * struct hostent *        -- The hostent structure containing the result of the query
  317. *                           (or NULL on error)
  318. *
  319. */
  320.  
  321. struct hostent * gethostbyaddr(const char *addrP, int, int)
  322. {
  323.     Boolean    done;
  324.     int i;
  325.  
  326.     if (SKg_INETSockets.Resolver()) {
  327.         h_errno = NO_RECOVERY;    
  328.         return NULL;
  329.     }
  330.  
  331.     for (i=0; i<NUM_ALT_ADDRS; i++)
  332.         SKg_MacHost.addr[i] = 0;
  333.  
  334.     done = false;
  335.  
  336.     if (AddrToName(*(ip_addr *)addrP, &SKg_MacHost, ResultProcPtr(DNRDone), (char *) &done) == cacheFault)
  337.         SPINP(!done,SKk_ADDR,0L);
  338.  
  339.     switch (SKg_MacHost.rtnCode) {
  340.     case noErr:             break;
  341.  
  342.     case cacheFault:        h_errno = NO_RECOVERY;        return(NULL);
  343.     case noNameServer:        h_errno = HOST_NOT_FOUND;    return(NULL);
  344.     case authNameErr:        h_errno = HOST_NOT_FOUND;    return(NULL);
  345.     case noAnsErr:            h_errno = TRY_AGAIN;        return(NULL);
  346.     case dnrErr:            h_errno = NO_RECOVERY;        return(NULL);
  347.     case outOfMemory:        h_errno = TRY_AGAIN;        return(NULL);
  348.     default:                h_errno = NO_RECOVERY;        return(NULL);
  349.     }
  350.  
  351.     /* for some reason there is a dot at the end of the name */
  352.     i = strlen(SKg_MacHost.cname) - 1;
  353.     if (SKg_MacHost.cname[i] == '.')
  354.         SKg_MacHost.cname[i] = 0;
  355.  
  356.     for (i=0; i<NUM_ALT_ADDRS; i++)
  357.         SKg_AddrPtrs[i] = (ip_addr *) &SKg_MacHost.addr[i];
  358.  
  359.     SKg_AddrPtrs[NUM_ALT_ADDRS] = NULL;
  360.  
  361.     return &SKg_UnixHost;
  362. }
  363.  
  364.  
  365. /*************************************************************************** *
  366. * FUNCTION:
  367. *
  368. * inet_ntoa
  369. *
  370. * DESCRIPTION:
  371. *
  372. * Convert a given internet address to the official fully qualified host
  373. * name for that address
  374. *
  375. * PARAMETERS:
  376. *
  377. * struct in_addr        -- The internet address of the host
  378. *
  379. * RETURNS:
  380. *
  381. * char *                -- The fully qualified name in standard dotted format
  382. *                           (e.g., dsg.harvard.edu)
  383. *
  384. */
  385.  
  386. extern "C" {
  387.  
  388. char * inet_ntoa(struct in_addr inaddr)
  389. {
  390.     if (SKg_INETSockets.Resolver()) {
  391.         h_errno = NO_RECOVERY;    
  392.         return NULL;
  393.     }
  394.     
  395.     (void) AddrToStr(inaddr.s_addr, SKg_MacHost.cname);
  396.  
  397.     return SKg_MacHost.cname;
  398. }
  399.  
  400. }  /* extern "C" */
  401.  
  402.  
  403. /*************************************************************************** *
  404. * FUNCTION:
  405. *
  406. * inet_addr
  407. *
  408. * DESCRIPTION:
  409. *
  410. * ???
  411. *
  412. * PARAMETERS:
  413. *
  414. * char *            -- ???
  415. *
  416. * RETURNS:
  417. *
  418. * struct in_addr    -- ???
  419. *
  420. */
  421.  
  422. extern "C" {
  423.  
  424. struct in_addr inet_addr(char *address)
  425. {
  426.     if (SKg_INETSockets.Resolver()) {
  427.         h_errno = NO_RECOVERY;    
  428.         return make_in_addr(0xFFFFFFFF);
  429.     }
  430.     
  431.     if (StrToAddr(address,&SKg_MacHost,NULL,NULL) != noErr)
  432.         return make_in_addr(0xFFFFFFFF);
  433.  
  434.     /* was the 'address' really a name? */
  435.     if (SKg_MacHost.cname[0] != 0)
  436.         return make_in_addr(0xFFFFFFFF);
  437.  
  438.     return make_in_addr(SKg_MacHost.addr[0]);
  439. }
  440.  
  441. }  /* extern "C" */
  442.  
  443.  
  444. /*************************************************************************** *
  445. * FUNCTION:
  446. *
  447. * gethostname
  448. *
  449. * DESCRIPTION:
  450. *
  451. * Get host name (in standard dotted format, e.g. dsg.harvard.edu) for
  452. * this Macintosh.  If DNS query fails, the IP address of this Mac is
  453. * returned in ascii format.
  454. *
  455. * PARAMETERS:
  456. *
  457. * char *        -- Pointer to buffer for return value
  458. * long            -- Length of above buffer
  459. *
  460. * RETURNS:
  461. *
  462. * int            -- Error return (0 = no error)
  463. *
  464. * NOTES:
  465. *
  466. * Returning ip address upon query failure is non-standard but necessary
  467. * because many Macs do not have officially registered names.
  468. *
  469. */
  470.  
  471. int gethostname(char *machname, long buflen)
  472. {
  473.     in_addr ipaddr;
  474.     struct    hostent *hp;
  475.     struct GetAddrParamBlock pbr;
  476.  
  477.     pbr.ioCRefNum = SKg_INETSockets.Driver();
  478.     pbr.csCode = ipctlGetAddr;
  479.  
  480.     if (PBControlSync(ParmBlkPtr(&pbr)))
  481.         goto resign;
  482.  
  483.     ipaddr = make_in_addr(pbr.ourAddress);
  484.  
  485.     hp = gethostbyaddr((char *) &ipaddr, sizeof(in_addr), AF_INET);
  486.  
  487.     if (!hp)
  488.         goto resign;
  489.     else
  490.         strncpy(machname, hp->h_name, unsigned(buflen));
  491.  
  492.     machname[buflen-1] = 0;  /* extra safeguard */
  493.  
  494.     return 0;
  495.  
  496.     /*****/
  497.     resign:
  498.     sprintf(machname, "%d.%d.%d.%d",
  499.                             ipaddr.s_addr>>24,
  500.                             ipaddr.s_addr>>16 & 0xff,
  501.                             ipaddr.s_addr>>8 & 0xff,
  502.                             ipaddr.s_addr & 0xff);
  503.     return 0;
  504. }
  505.  
  506.  
  507. /****************************************************************************
  508. * LOCAL UTILITIES AND SUPPORT FOR SERVICES TABLE */
  509.  
  510. static char *SKg_ServicesList[] =
  511. {
  512.     "echo            7/udp",
  513.     "discard        9/udp",
  514.     "time           37/udp",
  515.     "domain            53/udp",
  516.     "sunrpc            111/udp",
  517.     "tftp            69/udp",
  518.     "biff           512/udp",
  519.     "who            513/udp",
  520.     "talk           517/udp",
  521.     "ftp-data           20/tcp",
  522.     "ftp               21/tcp",
  523.     "telnet           23/tcp",
  524.     "smtp               25/tcp",
  525.     "time              37/tcp",
  526.     "whois          43/tcp",
  527.     "domain          53/tcp",
  528.     "hostnames      101/tcp",
  529.     "nntp           119/tcp",
  530.     "finger           79/tcp",
  531.     "ntp               123/tcp",
  532.     "uucp           540/tcp",
  533.     NULL
  534.   };
  535.  
  536. /* Globals for managing services */
  537. static char                 SKg_ServicesLine[128];
  538. static struct servent        SKg_ServicesEntry;
  539. static FILE *                 SKg_ServicesFile;
  540. static int                    SKg_ServicesPtr;
  541. static char *                SKg_ServicesAliases[8];
  542. static int                    SKg_ServicesStay = 0;
  543.   
  544. /* Local utility */
  545. void setservent(int stayopen)
  546. {
  547.     if (SKg_ServicesFile && SKg_ServicesFile != (FILE *) -1) {
  548.         rewind(SKg_ServicesFile);
  549.     }
  550.     SKg_ServicesPtr    = 0;
  551.     SKg_ServicesStay = SKg_ServicesStay || stayopen;
  552. }
  553.  
  554. /* Local utility */
  555. void endservent()
  556. {
  557.     if (SKg_ServicesFile && SKg_ServicesFile != (FILE *) -1) {
  558.         fclose(SKg_ServicesFile);
  559.         SKg_ServicesFile = NULL;
  560.     }
  561.     
  562.     SKg_ServicesStay = 0;
  563. }
  564.  
  565. /* Local utility */
  566. struct servent *  getservent()
  567. {
  568.     char *    p;
  569.     int        aliascount;
  570.     
  571.     if (!SKg_ServicesFile) {
  572.         short vRefNum;
  573.         long parID;
  574.         Str255 name = "\p/etc/services";
  575.         Str255 fullpath;
  576.         OSErr err;
  577.         
  578.         if (!FindFolder(kOnSystemDisk, kPreferencesFolderType, kDontCreateFolder, 
  579.                         &vRefNum, &parID)) {
  580.             
  581.             err = SK_FileRefToFullPath(vRefNum, parID, name, fullpath);
  582.             if (err != noErr)
  583.                 goto retry;
  584.             
  585.             SK_PtoCstr((char *) fullpath);
  586.             
  587.             SKg_ServicesFile = fopen((char *) fullpath, "r");
  588.             if (SKg_ServicesFile != NULL)
  589.                 goto retry;
  590.         }    
  591.         SKg_ServicesFile = (FILE *) -1;
  592.         SKg_ServicesPtr    = 0;
  593.       }
  594.     
  595. retry:
  596.     if (SKg_ServicesFile == (FILE *) -1)
  597.         if (!SKg_ServicesList[SKg_ServicesPtr])
  598.             return (struct servent *) NULL;
  599.         else
  600.             strcpy(SKg_ServicesLine, SKg_ServicesList[SKg_ServicesPtr++]);
  601.             
  602.     else if (!(fgets(SKg_ServicesLine, 128, SKg_ServicesFile)))
  603.         return (struct servent *) NULL;
  604.     
  605.     p = strpbrk(SKg_ServicesLine, "#\n");
  606.     if (p != NULL)
  607.         *p = 0;
  608.         
  609.     if (!SKg_ServicesLine[0])
  610.         goto retry;
  611.     
  612.     SKg_ServicesEntry.s_name = strtok(SKg_ServicesLine, " \t");
  613.     if (SKg_ServicesEntry.s_name == NULL)
  614.         goto retry;
  615.         
  616.     p = strtok(NULL, " \t");
  617.     if (p == NULL)
  618.         goto retry;
  619.     
  620.     SKg_ServicesEntry.s_proto = strpbrk(p, "/,");
  621.     if (SKg_ServicesEntry.s_proto == NULL)
  622.         goto retry;
  623.         
  624.     *SKg_ServicesEntry.s_proto++     = 0;
  625.     SKg_ServicesEntry.s_port         = htons(atoi(p));
  626.     SKg_ServicesEntry.s_aliases     = SKg_ServicesAliases;
  627.     
  628.     for (aliascount = 0; aliascount < 7; ) {
  629.         SKg_ServicesAliases[aliascount++] = strtok(NULL, " \t");
  630.         if (SKg_ServicesAliases[aliascount++] == NULL)
  631.             break;
  632.     }
  633.     
  634.     SKg_ServicesAliases[aliascount] = NULL;
  635.     
  636.     return &SKg_ServicesEntry;
  637. }
  638.  
  639.  
  640. /*************************************************************************** *
  641. * FUNCTION:
  642. *
  643. * getservbyname
  644. *
  645. * DESCRIPTION:
  646. *
  647. * Get a servent structure containing information about a given named
  648. * internet service.
  649. *
  650. * PARAMETERS:
  651. *
  652. * const char *        -- The null-terminated name of the desired internet service
  653. * const char *        -- Protocol to use (must be 'udp' or 'tcp')
  654. *
  655. * RETURNS:
  656. *
  657. * struct servent *    -- Pointer to structure containing the official name, port number
  658. *                       and aliases of the given internet service
  659. *
  660. */
  661.  
  662. struct servent * getservbyname(const char * name, const char * proto)
  663. {
  664.     struct servent *     ent;
  665.     char **                 al;
  666.     setservent(0);
  667.     
  668.     while (ent = getservent()) {
  669.         if (!strcmp(name, ent->s_name))
  670.             goto haveName;
  671.         
  672.         for (al = ent->s_aliases; *al; ++al)
  673.             if (!strcmp(name, *al))
  674.                 goto haveName;
  675.         
  676.         continue;
  677. haveName:
  678.         if (!proto || !strcmp(proto, ent->s_proto))
  679.             break;
  680.     }
  681.     
  682.     if (!SKg_ServicesStay)
  683.         endservent();
  684.     
  685.     return ent;
  686. }
  687.  
  688.  
  689. /*************************************************************************** *
  690. * FUNCTION:
  691. *
  692. * getservbyport
  693. *
  694. * DESCRIPTION:
  695. *
  696. * Get a servent structure containing information about a service running
  697. * on a given port.
  698. *
  699. * PARAMETERS:
  700. *
  701. * int            -- The port number
  702. * const char *    -- Protocol name (must be 'udp' or 'tcp')
  703. *
  704. * RETURNS:
  705. *
  706. * struct servent *    -- Pointer to structure containing the official name,
  707. *                       port number, and aliases of the given internet service
  708. *
  709. */
  710.  
  711. struct servent * getservbyport(int port, const char * proto)
  712. {
  713.     struct servent * ent;
  714.     
  715.     setservent(0);
  716.     
  717.     while (ent = getservent())
  718.         if (port == ent->s_port && (!proto || !strcmp(proto, ent->s_proto)))
  719.             break;
  720.     
  721.     if (!SKg_ServicesStay)
  722.         endservent();
  723.     
  724.     return ent;
  725.   }
  726.   
  727.  
  728. /*************************************************************************** *
  729. * FUNCTION:
  730. *
  731. * getprotobyname
  732. *
  733. * DESCRIPTION:
  734. *
  735. * Get a protoent structure containing information about a given named
  736. * internet protocol.
  737. *
  738. * PARAMETERS:
  739. *
  740. * char *            -- Protocol name (must be 'udp' or 'tcp')
  741. *
  742. * RETURNS:
  743. *
  744. * struct protoent *    -- Pointer to structure containing the official name, 
  745. *                      aliases, and protocol number for the given protocol
  746. *
  747. * NOTES:
  748. *
  749. */
  750.  
  751. /* Kludge globals for return values */
  752. static char SKg_TCP[] = "tcp";
  753. static char SKg_UDP[] = "udp";
  754.  
  755. /* Maximum number of protocol aliases */
  756. #define    SKk_MaxProtocolEntries 10
  757.  
  758. /* Globals for accumulating return values for calls to getprotobyname() */
  759. static struct protoent SKg_ProtocolEntries[SKk_MaxProtocolEntries];
  760. static int SKg_ProtocolEntriesCount=0;
  761.  
  762. struct protoent * getprotobyname(const char * name)
  763. {
  764.     struct protoent *pe;
  765.  
  766.     pe = &SKg_ProtocolEntries[SKg_ProtocolEntriesCount];
  767.     if (strcmp(name, "udp") == 0) {
  768.         pe->p_name = SKg_UDP;
  769.         pe->p_proto = IPPROTO_UDP;
  770.     } else if (strcmp (name, "tcp") == 0)  {
  771.         pe->p_name = SKg_TCP;
  772.         pe->p_proto = IPPROTO_TCP;
  773.     } else {
  774.         errno = EPROTONOSUPPORT;
  775.         return NULL;
  776.     }
  777.     pe->p_aliases = SKg_AliasPtrs;
  778.     SKg_ProtocolEntriesCount = (SKg_ProtocolEntriesCount +1) % SKk_MaxProtocolEntries;
  779.     return pe;
  780. }
  781.  
  782.  
  783. /*************************************************************************** *
  784. * FUNCTION:
  785. *
  786. * get_myaddress()
  787. *
  788. * DESCRIPTION:
  789. *
  790. * Get the socket internet address for this process.
  791. *
  792. * PARAMETERS:
  793. *
  794. * struct sockaddr_in *    -- Buffer space for the return value.
  795. *
  796. * RETURNS:
  797. *
  798. * The address family, address, and port (???) for this process.
  799. *
  800. * NOTES:
  801. *
  802. * Currently, this always returns the sin_port and sin_len fields
  803. * set to 0.  Not sure what these should be!
  804. *
  805. */
  806.  
  807. void get_myaddress(struct sockaddr_in *addr)
  808. {
  809.     struct in_addr ipaddr;
  810.     struct GetAddrParamBlock pbr;
  811.  
  812.     pbr.ioCRefNum = SKg_INETSockets.Driver();
  813.     pbr.csCode = ipctlGetAddr;
  814.  
  815.     if (PBControlSync(ParmBlkPtr(&pbr)))
  816.         return; /* Failure handling ? */
  817.  
  818.     ipaddr = make_in_addr(pbr.ourAddress);
  819.  
  820.     addr->sin_len = 0;    /* ?? */
  821.     addr->sin_family = AF_INET;
  822.     addr->sin_port = 0;   /* ?? */
  823.     memcpy(&(addr->sin_addr), &ipaddr, sizeof(struct in_addr));
  824. }
  825.  
  826.